{"componentChunkName":"component---src-templates-post-jsx","path":"/[JPA]8/","result":{"data":{"site":{"siteMetadata":{"title":"SUbbb"}},"markdownRemark":{"id":"ac8c493e-a661-53a5-989d-b84fcb728ed1","excerpt":"자바 ORM 표준 JPA 프로그래밍 - 김영한을 읽고 인용하고 정리하는 POST입니다. 프록시와 즉시로딩, 지연로딩\n: 프록시를 사용하면 연관된 객체를 처음부터 데이터베이스에서 조회하는 것이 아니라, 실제 사용하는 시점에 조회할 수 있다. 영속성 전이와 고아 객체\n: JPA는 연관된 객체를 함께 저장하거나 삭제할 수 있는 영속성 전이와, 고아 객체 제거라…","html":"<p><em>[자바 ORM 표준 JPA 프로그래밍 - 김영한]을 읽고 인용하고 정리하는 POST입니다.</em></p>\n<blockquote>\n<p><strong>프록시와 즉시로딩, 지연로딩</strong><br/>\n: 프록시를 사용하면 연관된 객체를 처음부터 데이터베이스에서 조회하는 것이 아니라, 실제 사용하는 시점에 조회할 수 있다.</p>\n<p><strong>영속성 전이와 고아 객체</strong><br/>\n: JPA는 연관된 객체를 함께 저장하거나 삭제할 수 있는 영속성 전이와, 고아 객체 제거라는 편리한 기능을 제공한다.</p>\n</blockquote>\n<h2>💫 프록시</h2>\n<p>엔티티 조회 시 연관관된 엔티티들이 항상 사용되지는 않는다. 비즈니스 로직에 따라 사용될 때도 있고, 그렇지 않은 때도 존재한다.</p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">// 회원과 팀 정보를 모두 출력하는 로직\npublic void printUserAndTeam(String memberId) {\n  Member member = em.find(Member.class, memberId);\n  Team team = member.getTeam();\n  System.out.println(&quot;회원 이름: &quot; + member.getUsername());\n  System.out.println(&quot;소속팀 이름: &quot; + team.getName());\n}</code>\n        </deckgo-highlight-code>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">// 회원 정보만 출력하는 로직\npublic void printUser(String memberId) {\n  Member member = em.find(Member.class, memberId);\n  System.out.println(&quot;회원 이름: &quot; + member.getUsername());\n}</code>\n        </deckgo-highlight-code>\n<ul>\n<li><code class=\"language-text\">Member</code> 는 <code class=\"language-text\">Team</code> 에 대해 다대일 관계를 가지고 있다. (회원 엔티티에 <code class=\"language-text\">Team</code> 이 저장)</li>\n<li><code class=\"language-text\">printUser()</code> 는 회원 엔티티만 사용하기에 <code class=\"language-text\">em.find()</code> 로 회원 엔티티 조회 시 회원과 연관된 팀 엔티티까지 조회하는 것은 효율적이지 않다. (어차피 사용하지 않음)</li>\n</ul>\n<p>JPA는 이런 문제 해결을 위해 엔티티가 실제 사용될 때까지 데이터베이스 조회를 지연하는 방법을 제공하는데, 이를 <strong>지연 로딩</strong>이라 한다.</p>\n<ul>\n<li>즉, <code class=\"language-text\">team.getTeam()</code> 처럼 팀 엔티티의 값을 <strong>실제 사용하는 시점에</strong> 데이터베이스에서 팀 엔티티에 필요한 데이터를 조회하는 것이다.</li>\n<li>지연 로딩을 위해서는 실제 엔티티 객체 대신에 <strong>데이터베이스 조회를 지연할 수 있는 가짜 객체</strong>가 필요한데, 이를 <strong>프록시 객체</strong>라 한다.</li>\n</ul>\n<blockquote>\n<p>JPA 표준 명세는 지연 로딩의 구현 방법을 JPA 구현체에 위임했다. 따라서 아래의 내용들은 Hibernate 구현체에 대한 내용이다. Hibernate는 프록시를 사용하는 방법과 바이트코드를 수정하는 2가지 방법으로 지연 로딩을 지원한다.</p>\n</blockquote>\n<h3>➰ 프록시 기초</h3>\n<p>JPA에서 식별자로 엔티티 하나를 조회할 때는 <code class=\"language-text\">em.find()</code> 를 사용한다. 이 메소드는 영속성 컨텍스트에 엔티티가 없으면 데이터베이스를 조회한다. 엔티티를 직접 조회하면, 조회한 엔티티를 <strong>실제 사용하든, 사용하지 않든 데이터베이스를 조회</strong>하게 된다.</p>\n<ul>\n<li>엔티티를 실제 사용하는 시점까지 데이터베이스 조회를 미루고 싶다면 <code class=\"language-text\">em.getReference()</code> 메소드를 사용하면 된다.</li>\n</ul>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">Member member = em.getReference(Member.class, &quot;member1&quot;);</code>\n        </deckgo-highlight-code>\n<ul>\n<li>이 메소드를 호출할 때 JPA는 데이터베이스를 조회하지 않고 실제 엔티티 객체도 생성하지 않는다. </li>\n<li>대신 <strong>데이터베이스 접근을 위임한 프록시 객체를 반환</strong>한다.</li>\n</ul>\n<p><strong>프록시의 특징</strong><br/>\n프록시 클래스는 실제 클래스(실제 Entity 클래스)를 상속 받아 만들어지므로 <strong>실제 클래스와 겉 모양이 같다.</strong> 따라서 사용하는 입장에서는 이것이 진짜 객체인지 프록시 객체인지 구분하지 않고 사용하면 된다.</p>\n<p>프록시 객체는 실제 객체에 대한 참조(<code class=\"language-text\">target</code>)를 보관한다. 그리고 프록시 객체의 메소드를 호출하면 <strong>프록시 객체는 실제 객체의 메소드를 호출</strong>한다.</p>\n<p><strong>프록시 객체의 초기화</strong><br/>\n프록시 객체는 <code class=\"language-text\">member.getName()</code> 같이 실제 사용될 때 데이터베이스를 조회해 실제 엔티티 객체를 생성하는데, 이를 프록시 객체의 초기화라 한다. 아래는 프록시 객체의 초기화 과정이다.</p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">// MemberProxy 반환\nMember member = em.getReference(Member.class, &quot;id1&quot;);\nmember.getName(); // getName();</code>\n        </deckgo-highlight-code>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">class MemberProxy extends Member {\n\tMember target = null;\n\n\tpublic String getName() {\n\t\tif (target == null) {\n\n\t\t\t// 초기화 요청\n\t\t\t// DB 조회\n\t\t\t// 실제 엔티티 생성 및 참조 보관\n\t\t\tthis.target = ...;\n\t\t}\n\n\t\t// target.getName();\n\t\treturn target.getName();\n\t}\n}</code>\n        </deckgo-highlight-code>\n<ol>\n<li>프록시 객체에 <code class=\"language-text\">member.getName()</code> 을 호출해 실제 데이터를 조회한다.</li>\n<li>프록시 객체는 실제 엔티티가 생성되어 있지 않으면(<code class=\"language-text\">if(target == null)</code>), 영속성 컨텍스트에 실제 엔티티 생성을 요청하는데 이를 <strong>초기화</strong>라 한다. </li>\n<li>영속성 컨텍스트는 데이터베이스를 조회해 실제 엔티티 객체를 생성한다.</li>\n<li>프록시 객체는 생성된 실제 엔티티 객체의 참조를 <code class=\"language-text\">Member target</code> 멤버변수에 보관한다.</li>\n<li>프록시 객체는 실제 엔티티 객체의 <code class=\"language-text\">getName()</code> 을 호출해 결과를 반환한다.</li>\n</ol>\n<p><strong>프록시의 특징</strong><br/></p>\n<ul>\n<li>프록시 객체는 첫 사용 시에만 초기화된다.</li>\n<li>프록시 객체를 초기화하는 것이 실제 엔티티로 바뀌는 것이 아니다. 프록시 객체가 초기화되면 프록시 객체를 통해 실제 엔티티에 접근할 수 있다.</li>\n<li>프록시 객체는 원본 엔티티를 상속받은 객체이므로 타입 체크 시에 주의해서 사용해야 한다.</li>\n<li>영속성 컨텍스트에 찾는 엔티티가 이미 있으면 데이터베이스를 조회할 필요가 없기에, <code class=\"language-text\">em.getReference()</code> 를 호출해도 프록시가 아닌 실제 엔티티를 반환한다.</li>\n<li>초기화는 영속성 컨텍스트의 도움을 받아야 가능하다. 따라서 준영속 상태의 프록시를 초기화하면 Hibernate는 <code class=\"language-text\">org.hibernate.LazyInitializationException</code> 예외를 발생시킨다.</li>\n</ul>\n<p><strong>준영속 상태와 초기화</strong><br/>\n준영속 상태와 초기화에 관련된 코드이다.</p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">Member member = em.getReference(Member.class, &quot;id1&quot;);\ntransaction.commit();\nem.close(); // 영속성 컨텍스트 종료\n\nmember.getName(); // 준영속 상태인데 초기화를 시도!</code>\n        </deckgo-highlight-code>\n<ul>\n<li>이미 영속성 컨텍스트를 종료해서, <code class=\"language-text\">member</code> 는 준영속 상태이다.</li>\n<li><code class=\"language-text\">getName()</code> 을 호출하면 프록시를 초기화해야 하는데 영속성 컨텍스트가 없으므로 실제 엔티티를 조회할 수 없다. 따라서 <strong>예외가 발생</strong>한다.</li>\n</ul>\n<h3>➰ 프록시와 식별자</h3>\n<p>엔티티를 프록시로 조회할 때, 식별자 값을 파라미터로 전달하는데 <strong>프록시 객체는 이 식별자 값을 보관</strong>한다.</p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">Team team = em.getReference(Team.class, &quot;team1&quot;); // 식별자 보관\nteam.getId(); // 초기화되지 않음</code>\n        </deckgo-highlight-code>\n<ul>\n<li>\n<p>프록시 객체는 식별자 값을 이미 가지고 있으므로, 식별자 값을 조회하는 <code class=\"language-text\">getId()</code> 를 호출해도 프록시를 초기화를 하지 않는다.</p>\n<ul>\n<li>단 <strong>엔티티 접근 방식을 <code class=\"language-text\">@Access(AccessType.PROPERTY)</code> 로 설정한 경우에만</strong> 초기화하지 않는다.</li>\n</ul>\n</li>\n</ul>\n<blockquote>\n<p>엔티티 접근 방식을 <code class=\"language-text\">@Access(AccessType.FIELD)</code> 로 설정하면 JPA는 <code class=\"language-text\">getId()</code> 메소드가 <code class=\"language-text\">id</code> 만 조회하는 메소드인지 다른 필드까지 활용해 어떤 일을 하는 메소드인지 알지 못해 프록시 객체를 초기화한다.</p>\n</blockquote>\n<blockquote>\n<p><strong><code class=\"language-text\">@Access</code></strong><br/>\n: JPA가 엔티티에 접근하는 방식을 지정하는 annotation</p>\n<ul>\n<li>\n<p>필드 방식</p>\n<ul>\n<li>필드에 직접 접근, <code class=\"language-text\">private</code> 이어도 접근</li>\n</ul>\n</li>\n<li>\n<p>프로퍼티 방식</p>\n<ul>\n<li>접근자(Getter)를 이용해 접근 </li>\n</ul>\n</li>\n</ul>\n</blockquote>\n<p>프록시는 다음처럼 연관관계를 설정할 때 유용하게 사용할 수 있다.</p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">Member member = em.find(Member.class, &quot;member1&quot;);\nTeam team = em.getReference(Team.class, &quot;team1&quot;); // SQL을 실행하지 않음\nmember.setTeam(team);</code>\n        </deckgo-highlight-code>\n<ul>\n<li>연관관계 설정 시에는 식별자 값만 사용하기에 프록시를 사용하면 데이터베이스 접근 횟수를 줄일 수 있다. (원래 같으면 INSERT하고, UPDATE하는 방식)</li>\n<li>참고로 연관관계 설정 시에는 엔티티 접근 방식을 필드로 설정해도 프록시를 초기화하지 않는다.</li>\n</ul>\n<h3>➰ 프록시 확인</h3>\n<p>JPA가 제공하는 <code class=\"language-text\">PersistenceUnitUtil.isLoaded(Object entity)</code> 메소드를 사용하면 프록시 인스턴스의 초기화 여부를 확인할 수 있다.</p>\n<ul>\n<li>아직 초기화되지 않았다면 <code class=\"language-text\">false</code> 를 반환한다.</li>\n<li>이미 초기화되었거나 프록시 인스턴스가 아니면 <code class=\"language-text\">true</code> 를 반환한다.</li>\n</ul>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">boolean isLoad = em.getEntityManagerFactory()\n\t\t\t\t\t.getPersistenceUnitUtil().isLoaded(entity);\n// or, boolean isLoad = emf.getPersistenceUnitUtil().isLoaded(entity);\nSystem.out.println(&quot;isLoad = &quot; + isLoad); // 초기화 여부 확인</code>\n        </deckgo-highlight-code>\n<p>조회한 엔티티가 진짜 엔티티인지 프록시로 조회한 것인지 확인하려면 <strong>클래스명을 직접 출력</strong>해보면 된다. 출력된 클래스명 뒤에 <code class=\"language-text\">...javassist...</code> 라 되어있다면 프록시이다. (<code class=\"language-text\">member.getClass().getName()</code>)</p>\n<blockquote>\n<p><strong>프록시 강제 초기화</strong><br/>\nhibernate의 <code class=\"language-text\">initialize()</code> 메소드로 강제 초기화가 가능하다.</p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">org.hibernate.Hibernate.initialize(order.getMember());</code>\n        </deckgo-highlight-code>\n</blockquote>\n<hr>\n<h2>💫 즉시 로딩과 지연 로딩</h2>\n<p>프록시 객체는 <strong>주로 연관된 데이터를 지연 로딩할 때 사용</strong>한다.</p>\n<p>회원 엔티티를 조회할 때, 연관된 팀 엔티티도 함께 데이터베이스에서 조회하는 것이 좋을까? 아니면 팀 엔티티는 실제 사용하는 시점에 데이터베이스에서 조회하는 것이 좋을까?</p>\n<ul>\n<li>JPA는 개발자가 연관된 엔티티의 조회 시점을 선택할 수 있도록 아래 두 가지 방법을 제공한다.</li>\n<li>\n<p>즉시 로딩 : 엔티티를 조회할 때 연관된 엔티티도 함께 조회한다.</p>\n<ul>\n<li><code class=\"language-text\">em.find()</code> 호출 시 연관된 엔티티도 함께 조회한다.</li>\n<li>설정 방법: <strong><code class=\"language-text\">@ManyToOne(fetch = FetchType.EAGER)</code></strong></li>\n</ul>\n</li>\n<li>\n<p>지연 로딩 : 연관된 엔티티를 실제 사용할 때 조회한다.</p>\n<ul>\n<li><code class=\"language-text\">member.getTeam().getName()</code> 처럼 연관된 엔티티를 실제 사용하는 시점에 JPA가 SQL을 호출해서 조회한다.</li>\n<li>설정 방법 : <strong><code class=\"language-text\">@ManyToOne(fetch = FetchType.LAZY)</code></strong></li>\n</ul>\n</li>\n</ul>\n<h3>➰ 즉시 로딩</h3>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">@Entity\npublic class Member {\n\n  //...\n  @ManyToOe(fetch = FetchType.EAGER)\n  @JoinColumn(name = &quot;TEAM_ID&quot;)\n  private Team team;\n  // ...\n}</code>\n        </deckgo-highlight-code>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">Member member = em.find(Member.class, &quot;member1&quot;);\nTeam team = member.getTeam(); // 객체그래프 탐색</code>\n        </deckgo-highlight-code>\n<ul>\n<li>즉시 로딩을 실행하는 코드이다. 회원을 조회할 때 팀 정보도 즉시 로딩한다.</li>\n<li>\n<p>회원과 팀 두 테이블을 조회해야 하므로, 쿼리를 2번 실행할 것 같지만, 대부분의 JPA 구현체는 <strong>즉시 로딩 최적화를 위해 가등하면 조인 쿼리를 사용</strong>한다.</p>\n<ul>\n<li>즉 위 예제에서는 회원과 팀을 조인해서 쿼리 한 번으로 두 엔티티를 모두 조회한다.</li>\n</ul>\n</li>\n</ul>\n<blockquote>\n<p><strong>NULL 제약 조건과 JPA 조인 전략</strong><br/>\n즉시 로딩 실행 SQL에서 외부 조인(LEFT OUTER JOIN)을 사용했다. 외래 키에 <code class=\"language-text\">NULL</code> 값을 허용해서 팀에 소속되지 않은 회원이 있을 수 있게 했다. 이 경우에는 팀에 소속되지 않은 회원과 팀의 내부 조인이 불가능하다. </p>\n<p>내부 조인보다는 외부 조인이 성능과 최적화에서 유리한데, 내부 조인을 사용하려면 어떻게 해야 할까? </p>\n<ul>\n<li>외래 키에 NOT NULL 제약 조건을 설정하면 값이 있는 것을 보장한다. 즉 내부 조인이 가능해진다.</li>\n<li>JPA에도 이런 사실을 알려주기 위해 <code class=\"language-text\">@JoinColumn(nullable = false)</code> 를 설정해 이 외래 키는 NULL 값을 허용하지 않는다는 것을 명시한다. 이를 통해 JPA는 외부 조인 대신 내부 조인을 사용한다.\n정리! <br/>\nJPA는 선택적 관계면 외부 조인을 사용하고, 필수 관계면 내부 조인을 사용한다.</li>\n</ul>\n</blockquote>\n<h3>➰ 지연 로딩</h3>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">@Entity\npublic class Member {\n  // ...\n  @ManyToOne(fetch = FetchType.LAZY)\n  @JoinColumn(name = &quot;TEAM_ID&quot;)\n  private Team team;\n  // ...\n}</code>\n        </deckgo-highlight-code>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">Member member = em.find(Member.class, &quot;member1&quot;);\nTeam team = member.getTeam(); // 객체그래프 탐색\nteam.getName(); // 팀 객체 실제 사용</code>\n        </deckgo-highlight-code>\n<ul>\n<li>지연 로딩 설정으로, <code class=\"language-text\">em.find()</code> 호출 시 회원만 조회하고 팀은 조회하지 않는다. </li>\n<li>대신 조회한 회원의 <code class=\"language-text\">team</code> 멤버 변수에 프록시 객체를 넣어둔다. (<code class=\"language-text\">Team team = member.getTeam()</code>)</li>\n<li>반환된 팀 객체는 프록시 객체다. 이는 실 사용때까지 데이터 로딩을 미루기에 지연 로딩이라 한다. 그리고 실제 데이터가 필요한 순간 데이터베이스를 조회해서 프록시 객체를 초기화한다.</li>\n</ul>\n<blockquote>\n<p>조회 대상이 영속성 컨텍스트에 이미 있으면 프록시 객체를 사용할 이유가 없다. 곧바로 실 객체를 사용한다.</p>\n</blockquote>\n<h3>➰ 즉시 로딩, 지연 로딩 정리</h3>\n<p>사실 상황에 따라 너무 다르다. </p>\n<ul>\n<li>지연 로딩 : 연관된 엔티티를 프록시로 조회한다. 프록시를 실제 사용할 때 초기화하면서 데이터베이스를 조회한다.</li>\n<li>즉시 로딩 : 연관된 엔티티를 즉시 조회한다. Hibernate는 가능하면 SQL 조인을 사용해 한 번에 조회한다.</li>\n</ul>\n<hr>\n<h2>💫 지연 로딩 활용</h2>\n<p>지연 로딩을 활용하는 예시이다. 아래와 같은 요구사항이 있다.</p>\n<ul>\n<li>회원은 팀 하나에만 소속할 수 있다. (N:1)</li>\n<li>회원은 여러 주문내역을 가진다. (1:N)</li>\n<li>주문내역은 상품정보를 가진다. (N:1)</li>\n</ul>\n<p>그리고 이를 분석하면 다음과 같은 결과를 얻을 수 있다.</p>\n<ul>\n<li>회원과 연관된 팀은 자주 함께 사용되었다. 따라서 이를 <strong>즉시 로딩</strong>으로 설정했다.</li>\n<li>회원과 연관된 주문내역은 가끔 사용되었다. 따라서 <strong>지연 로딩</strong>으로 설정했다.</li>\n<li>주문내역과 연관된 상품정보는 자주 함께 사용되었다. 따라서 <strong>즉시 로딩</strong>으로 설정했다.</li>\n</ul>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">@Entity\npublic class Member {\n\n  @Id\n  private String id;\n  private String username;\n  private Integer age;\n\n  @ManyToOne(fetch = FetchType.EAGER)\n  private Team team;\n\n  @OneToMany(mappedBy = &quot;member&quot;, fetch = FetchType.LAZY)\n  private List&lt;Order&gt; orders;\n}</code>\n        </deckgo-highlight-code>\n<h3>➰ 프록시와 컬렉션 래퍼</h3>\n<p>지연 로딩으로 설정하면 실제 엔티티 대신 프록시 객체를 사용한다. 프록시 객체는 실제 자신이 사용될 때까지 데이터베이스를 조회하지 않는다. Hibernate는 엔티티를 영속 상태로 만들 때 엔티티에 컬렉션이 있으면 컬렉션을 추적하고 관리할 목적으로 원본 컬렉션을 Hibernate가 제공하는 내장 컬렉션으로 변경하는데, 이를 <strong>컬렉션 래퍼</strong>라 한다. </p>\n<ul>\n<li>출력 결과에서 컬랙션 래퍼인 <code class=\"language-text\">org.hibernate.collection.internal.PersistentBag</code> 이 반환되는 것을 확인할 수 있다.</li>\n</ul>\n<p>엔티티를 지연 로딩하면, 프록시 객체를 사용해 지연 로딩을 수행하지만 주문내역과 같은 <strong>컬렉션은 컬렉션 래퍼가 지연 로딩을 처리</strong>해준다. 컬렉션은 컬렉션에서 실제 데이터를 조회할 때 데이터베이스를 조회해서 초기화한다.</p>\n<h3>➰ JPA 기본 페치 전략</h3>\n<p><code class=\"language-text\">fetch</code> 속성의 기본 설정값은 다음과 같다.</p>\n<ul>\n<li><code class=\"language-text\">@ManyToOne</code> , <code class=\"language-text\">@OneToOne</code> :  즉시 로딩</li>\n<li><code class=\"language-text\">@OneToMany</code> , <code class=\"language-text\">@ManyToMany</code> : 지연 로딩</li>\n</ul>\n<p>JPA의 기본 페치 전략은, 연관된 엔티티가 하나면 즉시 로딩, 컬렉션이면 지연 로딩을 사용한다.</p>\n<ul>\n<li>컬렉션을 로딩하는 것은 비용이 많이 들고 잘못하면 너무 많은 데이터를 로딩할 수 있기 때문이다. </li>\n</ul>\n<blockquote>\n<p>모든 연관관계에 지연 로딩을 사용하는 것을 추천한다. 개발이 어느 정도 완료되었다면 필요한 곳에만 즉시 로딩을 사용하도록 최적화한다. (SQL을 직접 사용하게 되면 이러한 유연성을 가지기 어렵다.)</p>\n</blockquote>\n<h3>➰ 컬렉션에 FetchType.EAGER 사용 시 주의점</h3>\n<p>즉시 로딩사용 시의 주의점이다.</p>\n<ul>\n<li>\n<p><strong>컬렉션을 하나 이상 즉시 로딩하는 것은 권장하지 않는다.</strong></p>\n<ul>\n<li>컬렉션과 조인한다는 것은 데이터베이스 테이블로 본다면 일대다 조인이다. 이는 결과 데이터가 다 쪽에 있는 수만큼 증가하게 된다.</li>\n<li>문제는 서로 다른 컬렉션을 2개 이상 조인할 때 발생하는데, 결과 데이터가 너무 많아져 애플리케이션의 성능 저하를 발생시킬 수 있다. JPA는 이렇게 조회된 결과를 메모리에서 필터링해 반환한다. </li>\n</ul>\n</li>\n<li>\n<p><strong>컬렉션 즉시 로딩은 항상 외부 조인을 사용한다.</strong></p>\n<ul>\n<li>다대일 관계인 회원 테이블과 팀 테이블 조인 시 회원 테이블의 외래 키에 <code class=\"language-text\">not null</code> 제약조건을 걸어두면 모든 회원은 팀에 소속되어 항상 내부 조인을 사용해도 된다.</li>\n<li>반대로 팀 테이블에서 회원 테이블로 일대다 관계를 조인할 때 회원이 한 명도 없는 팀을 내부 조인하면 팀까지 조회되지 않는 문제가 발생하고 이는 제약조건으로 막을 수 없는 문제이므로 외부 조인을 사용해야 한다.</li>\n</ul>\n</li>\n</ul>\n<blockquote>\n<p><code class=\"language-text\">FetchType.EAGER</code> 설정과 조인 전략</p>\n<ul>\n<li>\n<p><code class=\"language-text\">@ManyToOne</code> , <code class=\"language-text\">@OneToOne</code></p>\n<ul>\n<li><code class=\"language-text\">(optional = false)</code> : 내부 조인</li>\n<li><code class=\"language-text\">(optional = true)</code> : 외부 조인</li>\n</ul>\n</li>\n<li>\n<p><code class=\"language-text\">@OneToMany</code> , <code class=\"language-text\">@ManyToMany</code></p>\n<ul>\n<li><code class=\"language-text\">(optional = false)</code> : 외부 조인</li>\n<li><code class=\"language-text\">(optional = true)</code> : 외부 조인</li>\n</ul>\n</li>\n</ul>\n</blockquote>\n<hr>\n<h2>💫 영속성 전이: CASCADE</h2>\n<p><strong>특정 엔티티를 영속 상태로 만들 때 연관된 엔티티도 함께 영속 상태로 만들고 싶으면</strong> 영속성 전이 기능(Transitive Persistence)을 사용하면 된다.</p>\n<ul>\n<li>JPA는 <code class=\"language-text\">CASCADE</code> 옵션으로 이를 제공한다.</li>\n<li>영속성 전이를 사용해 부모 엔티티를 저장할 때 자식 엔티티도 함께 저장할 수 있다.</li>\n</ul>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">@Entity\npublic class Parent {\n\n  @Id @GeneratedValue\n  private Long id;\n\n  @OneToMany(mappedBy = &quot;parent&quot;)\n  private List&lt;Child&gt; children = new ArrayList&lt;&gt;();\n  ...\n\n}</code>\n        </deckgo-highlight-code>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">@Entity\npublic class Child {\n\n  @Id @GeneratedValue\n  private Long id;\n\n  @ManyToOne\n  private Parent parent;\n  ...\n  \n}</code>\n        </deckgo-highlight-code>\n<ul>\n<li>부모 엔티티가 여러 자식 엔티티를 가지고 있고, 부모 1명에 자식 2명을 저장한다면 아래와 같은 코드를 작성할 수 있다.</li>\n</ul>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">private static void saveNoCascade(EntityManager em) {\n\n  // 부모 저장\n  Parent parent = new Parent;\n  em.persist(parent);\n\n  // 1번 자식 저장\n  Child child1 = new Child();\n  child1.setParent(parent);\n  parent.getChildren().add(child1);\n  em.persist(child1);\n\n  // 2번 자식 저장\n  Child child2 = new Child();\n  child2.setParent(parent);\n  parent.getChildren().add(child2);\n  em.persist(child2);\n}</code>\n        </deckgo-highlight-code>\n<ul>\n<li><strong>JPA에서 엔티티를 저장할 때 연관된 모든 엔티티는 영속 상태</strong>여야 한다. 위 예제에서도 부모 엔티티를 먼저 영속 상태로 만들고, 이후 자식 엔티티들을 영속 상태로 만든다.</li>\n<li>이런 경우 영속성 전이를 사용해 부모만 영속 상태로 만들면, 연관된 자식까지 한 번에 영속 상태로 만들 수 있다.</li>\n</ul>\n<h3>➰ 영속성 전이: 저장</h3>\n<p>영속성 전이를 활성화하는 <code class=\"language-text\">CASCADE</code> 옵션을 적용해보자.</p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">@Entity\npublic class Parent {\n  ...\n  @OneToMany(mappedBy = &quot;parent&quot;, cascade = CascadeType.PERSIST)\n  private List&lt;Child&gt; children = new ArrayList&lt;&gt;();\n  ...\n\n}</code>\n        </deckgo-highlight-code>\n<ul>\n<li>부모를 영속화할 때 연관된 자식들도 함께 영속화하라는 옵션을 설정했다.</li>\n</ul>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">private static void saveNoCascade(EntityManager em) {\n\n  Child child1 = new Child();\n  Child child2 = new Child();\n\n  // 부모 저장\n  Parent parent = new Parent;\n  child1.setParent(parent);\n  child2.setParent(parent);\n  parent.getChildren().add(child1);\n  parent.getChildren().add(child2);\n\n  em.persist(parent);\n}</code>\n        </deckgo-highlight-code>\n<ul>\n<li>간편하게 부모와 자식 엔티티를 한 번에 영속화하는 것을 확인할 수 있다.</li>\n</ul>\n<blockquote>\n<p>영속성 전이는 연관관계를 매핑하는 것과는 관련이 없고, 단지 <strong>엔티티를 영속화할 때 연관된 엔티티도 같이 영속화하는 편리한 기능</strong>일 뿐이다.</p>\n</blockquote>\n<h3>➰ 영속성 전이: 삭제</h3>\n<p>영속화한 부모 자식 엔티티를 모두 제거하려면 각각의 엔티티를 하나씩 제거해야 한다.</p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">Parent findParent = em.find(Parent.class, 1L);\nChild findChild1 = em.find(Child.class, 1L);\nChild findChild2 = em.find(Child.class, 2L);\n\nem.remove(findChild1);\nem.remove(findChild2);\nem.remove(findParent);</code>\n        </deckgo-highlight-code>\n<p>영속성 전이는 엔티티 삭제 시에도 사용할 수 있다. <code class=\"language-text\">CascadeType.REMOVE</code> 로 설정하고 부모 엔티티만 삭제하면 연관된 자식 엔티티도 함께 삭제된다.</p>\n<ul>\n<li>모든 엔티티 제거를 위한 DELETE SQL을 실행하고, 삭제 순서는 외래 키 제약조건을 고려해 자식 먼저 삭제한 다음 부모를 삭제한다.</li>\n<li>만약 위 설정 없이 부모 엔티티만 삭제하면, 자식 엔티티는 제거되지 않았지만 외래 키 제약조건으로 인해, 데이터베이스에서 외래 키 무결성 제약조건이 깨지는 예외가 발생한다.</li>\n</ul>\n<h3>➰ CASCADE의 종류</h3>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">public enum CascadeType {\n  ALL, \n  PERSIST,\n  MERGE,\n  REMOVE,\n  REFRESH,\n  DETACH\n}</code>\n        </deckgo-highlight-code>\n<blockquote>\n<p>참고로 <code class=\"language-text\">PERSIST</code> , <code class=\"language-text\">REMOVE</code> 는 <code class=\"language-text\">em.persist()</code> , <code class=\"language-text\">em.remove()</code> 실행 즉시 전이가 발생하는 것이 아니라 플러시 호출 시 전이가 발생한다.</p>\n</blockquote>\n<hr>\n<h2>💫 고아 객체</h2>\n<p>JPA는 <strong>부모 엔티티와 연관관계가 끊어진 자식 엔티티를 자동으로 삭제</strong>하는 기능을 제공하는데 이를 고아 객체(ORPHAN) 제거라 한다. </p>\n<ul>\n<li>이 기능으로 부모 엔티티의 컬렉션에서 자식 엔티티의 참조만 제거해 자식 엔티티가 자동으로 삭제되도록 해보자.</li>\n</ul>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">@Entity\npublic class Parent {\n\n  @Id @GeneratedValue\n  private Long id;\n\n  @OneToMany(mappedBy = &quot;parent&quot;, orphanRemoval = true)\n  private List&lt;Child&gt; Children = new ArrayList&lt;&gt;();\n  ...\n\n}</code>\n        </deckgo-highlight-code>\n<ul>\n<li>고아 객체 제거 기능 활성화를 명시하는 설정을 추가했다. 이제 컬렉션에서 제거한 엔티티는 자동으로 삭제된다.</li>\n<li>컬렉션에서 첫 번째 자식을 제거하면, DELETE SQL을 실행하여 데이터베이스의 데이터 또한 삭제한다.</li>\n<li>\n<p>이 기능은 영속성 컨텍스트를 플러시할 때 적용되므로 플러시 시점에 DELETE SQL이 실행된다.</p>\n<ul>\n<li>모든 자식 엔티티 제거를 위해서는 컬렉션을 비우기만 하면 된다.</li>\n</ul>\n</li>\n</ul>\n<p>고아 객체 제거는 <strong>참조가 제거된 엔티티는 다른 곳에서 참조하지 않는 고아 객체로 보고, 삭제하는 기능</strong>이다.</p>\n<ul>\n<li>따라서 참조하는 곳이 하나일때만 사용해야 한다! (즉, 특정 엔티티가 개인 소유하는 엔티티만 사용)</li>\n<li>따라서 <code class=\"language-text\">orphanRemoval</code> 속성은 <code class=\"language-text\">@OneToOne</code> , <code class=\"language-text\">@OneToMany</code> 로 일대~인 경우만 사용할 수 있다.</li>\n<li>\n<h2>추가 기능이 있는데, 부모를 제거하면 자식은 자연스레 고아가 된다. 따라서 <strong>부모를 제거하면 자식도 함께 제거하는 기능</strong>이 있다. 이는 <code class=\"language-text\">CascadeType.REMOVE</code> 를 설정한 것과 동일하다.</h2>\n</li>\n</ul>\n<h2>💫 영속성 전이 + 고아 객체, 생명주기</h2>\n<p><code class=\"language-text\">CascadeType.ALL</code> + <code class=\"language-text\">orphanRemoval = true</code> 를 동시에 사용하면 어떻게 될까? </p>\n<ul>\n<li>일반적으로 엔티티는 <code class=\"language-text\">em.persist()</code> 를 통해 영속화되고, <code class=\"language-text\">em.remove()</code> 를 통해 제거된다. 이는 엔티티 스스로 생명주기를 관리한다는 뜻이다. </li>\n<li>그런데 두 옵션을 모두 설정하면 부모 엔티티를 통해 자식의 생명주기를 관리할 수 있다.</li>\n</ul>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">// 자식을 저장하려면 부모에 등록만 하면 된다. (CASCADE)\nParent parent = em.find(Parent.class, parentId);\nparent.setChild(child1);</code>\n        </deckgo-highlight-code>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">// 자식을 삭제하려면 부모에서 제겅하면 된다. (orphanRemoval)\nParent parent = em.find(Parent.class, parentId);\nparent.getChildren().remove(removeObject);</code>\n        </deckgo-highlight-code>\n<h2>📕 출처</h2>\n<p><strong>자바 ORM 표준 JPA 프로그래밍</strong> - 김영한</p>","frontmatter":{"title":"📚 8. 프록시와 연관관계 관리","date":"March 21, 2022","update":"March 21, 2022","tags":["Java","JPA","SpringBoot"],"series":"📚 ORM 표준 JPA"},"fields":{"slug":"/[JPA]8/","readingTime":{"minutes":29.25}}},"seriesList":{"edges":[{"node":{"id":"66d0397b-0a88-53f8-9e40-01878853acdd","fields":{"slug":"/[JPA]1/"},"frontmatter":{"title":"📚 1. JPA 소개"}}},{"node":{"id":"f86fa867-f096-52ce-854a-ef00e49ebcdb","fields":{"slug":"/[JPA]2/"},"frontmatter":{"title":"📚 2. JPA 시작"}}},{"node":{"id":"ffb8392d-d300-51c1-8e71-a8943ef4b58d","fields":{"slug":"/[JPA]3/"},"frontmatter":{"title":"📚 3. 영속성 관리"}}},{"node":{"id":"f45d0c27-c0da-5191-8c86-2aef34b75f27","fields":{"slug":"/[JPA]4/"},"frontmatter":{"title":"📚 4. 엔티티 매핑"}}},{"node":{"id":"c710307c-927c-5c1b-80fb-c45a4ff20616","fields":{"slug":"/[JPA]5/"},"frontmatter":{"title":"📚 5. 연관관계 매핑 기초"}}},{"node":{"id":"24c890e9-eebe-56bf-9db2-8660dcb3b783","fields":{"slug":"/[JPA]6/"},"frontmatter":{"title":"📚 6. 다양한 연관관계 매핑"}}},{"node":{"id":"26e75089-52ac-5b50-98c9-c2806068b034","fields":{"slug":"/[JPA]7/"},"frontmatter":{"title":"📚 7. 고급 매핑"}}},{"node":{"id":"ac8c493e-a661-53a5-989d-b84fcb728ed1","fields":{"slug":"/[JPA]8/"},"frontmatter":{"title":"📚 8. 프록시와 연관관계 관리"}}},{"node":{"id":"5003d7a8-381f-550d-aecd-28caba14aba9","fields":{"slug":"/[JPA]9/"},"frontmatter":{"title":"📚 9. 값 타입"}}},{"node":{"id":"a41dc548-d976-533a-a680-96e86a627d35","fields":{"slug":"/[JPA]10/"},"frontmatter":{"title":"📚 10. 객체지향 쿼리 언어"}}},{"node":{"id":"4ef1a134-ac1d-5e69-9f85-7c1b5d7a8244","fields":{"slug":"/[JPA]11/"},"frontmatter":{"title":"📚 11. 웹 애플리케이션 제작"}}},{"node":{"id":"1a74ae89-3758-5cb9-938c-b8238d176c8c","fields":{"slug":"/[JPA]12/"},"frontmatter":{"title":"📚 12. 스프링 데이터 JPA"}}},{"node":{"id":"5900f638-1417-5a4a-a147-a228540a920b","fields":{"slug":"/[JPA]13/"},"frontmatter":{"title":"📚 13. 웹 애플리케이션과 영속성 관리"}}},{"node":{"id":"5f07d9ea-eadc-54ea-90b2-efe93297170f","fields":{"slug":"/[JPA]14/"},"frontmatter":{"title":"📚 14. 컬렉션과 부가 기능"}}},{"node":{"id":"838bd515-9bd3-5d4b-8f49-723d3f55688c","fields":{"slug":"/[JPA]15/"},"frontmatter":{"title":"📚 15. 고급 주제와 성능 최적화"}}},{"node":{"id":"1f449b33-36ba-58f9-915f-be058ee6ba3e","fields":{"slug":"/[JPA]16/"},"frontmatter":{"title":"📚 16. 트랜잭션과 락, 2차 캐시"}}}]},"previous":{"fields":{"slug":"/[Java지식]HashMap&LinkedHashMap/"},"frontmatter":{"title":"📃 HashMap과 LinkedHashMap"}},"next":{"fields":{"slug":"/[JPA]9/"},"frontmatter":{"title":"📚 9. 값 타입"}}},"pageContext":{"id":"ac8c493e-a661-53a5-989d-b84fcb728ed1","series":"📚 ORM 표준 JPA","previousPostId":"ccb919b8-dc72-524a-8a71-a85c4554249f","nextPostId":"5003d7a8-381f-550d-aecd-28caba14aba9"}},"staticQueryHashes":[]}